{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 8251,
     "status": "ok",
     "timestamp": 1650011468229,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "BQXVYW2T_DcQ"
   },
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import rl_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1650011468231,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "ClM8RKjB_DcR"
   },
   "outputs": [],
   "source": [
    "## 构造智能体 agent 的大脑，也就是输入状态，返回该状态下，选择每个动作的概率\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim\n",
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)  ## 返回该状态下，选择的动作的概率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1650011468231,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "w0W82SjM_DcS"
   },
   "outputs": [],
   "source": [
    "## 策略梯度算法\n",
    "## 智能体\n",
    "class REINFORCE:\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 device):\n",
    "        ## 实例化智能体的大脑\n",
    "        self.policy_net = PolicyNet(state_dim, hidden_dim,\n",
    "                                    action_dim).to(device)\n",
    "        self.optimizer = torch.optim.Adam(self.policy_net.parameters(),\n",
    "                                          lr=learning_rate)  # 使用Adam优化器\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):            # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.policy_net(state)       ## 拿到该状态下，每个动作的选择概率\n",
    "        action_dist = torch.distributions.Categorical(probs)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()        ## 对该状态下，所有的动作采样，采样的概率是probs\n",
    "        return action.item()                 ## 返回依概率采样得到的动作\n",
    "\n",
    "    ## 训练策略网络的，用一条序列来训练\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 奖励、状态和动作\n",
    "        reward_list = transition_dict['rewards']\n",
    "        state_list = transition_dict['states']\n",
    "        action_list = transition_dict['actions']\n",
    "            \n",
    "        G = 0      ##   初始化回报值 = 0\n",
    "        self.optimizer.zero_grad()     ## 所有参数的梯度置0\n",
    "        for i in reversed(range(len(reward_list))):  # 从最后一步算起\n",
    "            reward = reward_list[i]   ##  拿到这一步的奖励\n",
    "            state = torch.tensor([state_list[i]], dtype=torch.float).to(self.device)    ##  拿到这一步的状态\n",
    "            action = torch.tensor([action_list[i]]).view(-1, 1).to(self.device)         ##  拿到这一步的动作\n",
    "            log_prob = torch.log(self.policy_net(state).gather(1, action))          ## 算动作概率的log值 \n",
    "            G = self.gamma * G + reward   ## 算这一步状态s的回报\n",
    "            loss = -log_prob * G  # 每一步的损失函数             ##  算这一步的动作回报，并取相反数的\n",
    "            loss.backward()  # 反向传播计算梯度 ## 梯度会累加的\n",
    "        self.optimizer.step()  # 梯度下降 update 参数 ## 所以一个序列以后，网络 policy_net 的参数才会 update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 策略梯度算法\n",
    "class REINFORCE:\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 device):\n",
    "        ## 实例化智能体的大脑\n",
    "        self.policy_net = PolicyNet(state_dim, hidden_dim,\n",
    "                                    action_dim).to(device)\n",
    "        self.optimizer = torch.optim.Adam(self.policy_net.parameters(),\n",
    "                                          lr=learning_rate)  # 使用Adam优化器\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):            # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.policy_net(state)       ## 拿到该状态下，每个动作的选择概率\n",
    "        action_dist = torch.distributions.Categorical(probs)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()        ## 对该状态下，所有的动作采样，采样的概率是probs\n",
    "        return action.item()                 ## 返回依概率采样得到的动作\n",
    "\n",
    "    ## 训练策略网络的，用一条序列来训练\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 奖励、状态和动作\n",
    "        reward_list = transition_dict['rewards']\n",
    "        state_list = transition_dict['states']\n",
    "        action_list = transition_dict['actions']\n",
    "            \n",
    "        G = 0      ##   初始化回报值 = 0\n",
    "        self.optimizer.zero_grad()     ## 所有参数的梯度置0\n",
    "        for i in reversed(range(len(reward_list))):  # 从最后一步算起\n",
    "            reward = reward_list[i]   ##  拿到这一步的奖励\n",
    "            state = torch.tensor([state_list[i]], dtype=torch.float).to(self.device)    ##  拿到这一步的状态\n",
    "            action = torch.tensor([action_list[i]]).view(-1, 1).to(self.device)         ##  拿到这一步的动作\n",
    "            ret = self.policy_net(state)\n",
    "            kl = []\n",
    "            for ik in range(len(ret)):\n",
    "                kl.append(ret[ik, action[ik][0]])\n",
    "            kl = torch.tensor(kl)\n",
    "            # kl = ret.gather(1, action)\n",
    "\n",
    "            log_prob = torch.log(kl)          ## 算动作概率的log值 \n",
    "            G = self.gamma * G + reward   ## 算这一步状态s的回报\n",
    "            loss = -log_prob * G  # 每一步的损失函数             ##  算这一步的动作回报，并取相反数的\n",
    "\n",
    "            # log_prob.retain_grad()\n",
    "            # kl.retain_grad()\n",
    "            # kkk.retain_grad()\n",
    "            # loss.backward()  # 反向传播计算梯度 ## 梯度会累加的\n",
    "            # k = float(torch.flatten(log_prob.grad).numpy()[0])\n",
    "            # k_ = float(torch.flatten(kl.grad).numpy()[0])\n",
    "            # k__ = list(torch.flatten(kkk.grad).numpy())\n",
    "\n",
    "            grad_log = -G\n",
    "            grad_kl = grad_log * (1 / kl)\n",
    "            grad_kkk = [0, grad_kl[0]] if action[0][0] > 0 else [grad_kl[0], 0]\n",
    "            ret.backward(torch.tensor([grad_kkk]))\n",
    "            # assert abs(grad_log - k) < 1e-6\n",
    "            # assert abs(grad_kl - k_) < 1e-6\n",
    "            # assert np.sum(abs(np.array(grad_kkk) - np.array(k__))) < 1e-6\n",
    "        self.optimizer.step()  # 梯度下降 update 参数 ## 所以一个序列以后，网络 policy_net 的参数才会 update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 102519,
     "status": "ok",
     "timestamp": 1650011570745,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "WeykNnJM_DcT",
    "outputId": "bed6d0bb-f499-4611-b74d-dee1959d8c06"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|███████████████████████████████████████| 100/100 [00:02<00:00, 40.63it/s, episode=100, return=30.700]\n",
      "Iteration 1: 100%|██████████████████████████████████████| 100/100 [00:06<00:00, 14.39it/s, episode=200, return=141.800]\n",
      "Iteration 2: 100%|██████████████████████████████████████| 100/100 [00:11<00:00,  8.49it/s, episode=300, return=168.900]\n",
      "Iteration 3: 100%|██████████████████████████████████████| 100/100 [00:13<00:00,  7.58it/s, episode=400, return=172.200]\n",
      "Iteration 4: 100%|██████████████████████████████████████| 100/100 [00:13<00:00,  7.35it/s, episode=500, return=191.700]\n",
      "Iteration 5: 100%|██████████████████████████████████████| 100/100 [00:12<00:00,  7.69it/s, episode=600, return=195.500]\n",
      "Iteration 6: 100%|██████████████████████████████████████| 100/100 [00:13<00:00,  7.22it/s, episode=700, return=195.400]\n",
      "Iteration 7: 100%|██████████████████████████████████████| 100/100 [00:14<00:00,  7.04it/s, episode=800, return=200.000]\n",
      "Iteration 8: 100%|██████████████████████████████████████| 100/100 [00:14<00:00,  6.82it/s, episode=900, return=200.000]\n",
      "Iteration 9: 100%|█████████████████████████████████████| 100/100 [00:14<00:00,  6.93it/s, episode=1000, return=197.900]\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 1e-3\n",
    "num_episodes = 1000\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = \"CartPole-v1\"\n",
    "env = gym.make(env_name)\n",
    "_ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "agent = REINFORCE(state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                  device)\n",
    "\n",
    "return_list = []\n",
    "for i in range(10):\n",
    "    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes / 10)):\n",
    "            episode_return = 0\n",
    "            transition_dict = {\n",
    "                'states': [],\n",
    "                'actions': [],\n",
    "                'next_states': [],\n",
    "                'rewards': [],\n",
    "                'dones': []\n",
    "            }\n",
    "            state = env.reset()\n",
    "            if len(state)!=2*2:\n",
    "                state = state[0]\n",
    "            done = False\n",
    "            ## 采样一条序列的\n",
    "            while not done:\n",
    "                action = agent.take_action(state)    ##  根据状态采取动作的\n",
    "                ##  环境执行动作，并反馈下一个状态、动作的奖励、是否完成、步长太长的，info\n",
    "                next_state, reward, terminated, truncated, info = env.step(action)\n",
    "                done = terminated | truncated       ## 终止或者步长太长，都会导致已经结束\n",
    "                ## record该序列的 该时刻状态、该时刻动作、下一个状态、动作的奖励、是否完成的\n",
    "                transition_dict['states'].append(state)\n",
    "                transition_dict['actions'].append(action)\n",
    "                transition_dict['next_states'].append(next_state)\n",
    "                transition_dict['rewards'].append(reward)\n",
    "                transition_dict['dones'].append(done)\n",
    "                state = next_state    ## 下一个状态赋值到当前状态\n",
    "                episode_return += reward  ##累加奖励的\n",
    "            return_list.append(episode_return)\n",
    "            agent.update(transition_dict)  ## 训练策略网络的，用一条序列来训练\n",
    "            if (i_episode + 1) % 10 == 0:\n",
    "                pbar.set_postfix({\n",
    "                    'episode':\n",
    "                    '%d' % (num_episodes / 10 * i + i_episode + 1),\n",
    "                    'return':\n",
    "                    '%.3f' % np.mean(return_list[-10:])\n",
    "                })\n",
    "            pbar.update(1)\n",
    "\n",
    "# Iteration 0: 100%|██████████| 100/100 [00:04<00:00, 23.88it/s, episode=100,\n",
    "# return=55.500]\n",
    "# Iteration 1: 100%|██████████| 100/100 [00:08<00:00, 10.45it/s, episode=200,\n",
    "# return=75.300]\n",
    "# Iteration 2: 100%|██████████| 100/100 [00:16<00:00,  4.75it/s, episode=300,\n",
    "# return=178.800]\n",
    "# Iteration 3: 100%|██████████| 100/100 [00:20<00:00,  4.90it/s, episode=400,\n",
    "# return=164.600]\n",
    "# Iteration 4: 100%|██████████| 100/100 [00:21<00:00,  4.58it/s, episode=500,\n",
    "# return=156.500]\n",
    "# Iteration 5: 100%|██████████| 100/100 [00:21<00:00,  4.73it/s, episode=600,\n",
    "# return=187.400]\n",
    "# Iteration 6: 100%|██████████| 100/100 [00:22<00:00,  4.40it/s, episode=700,\n",
    "# return=194.500]\n",
    "# Iteration 7: 100%|██████████| 100/100 [00:23<00:00,  4.24it/s, episode=800,\n",
    "# return=200.000]\n",
    "# Iteration 8: 100%|██████████| 100/100 [00:23<00:00,  4.33it/s, episode=900,\n",
    "# return=200.000]\n",
    "# Iteration 9: 100%|██████████| 100/100 [00:22<00:00,  4.14it/s, episode=1000,\n",
    "# return=186.100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 1119,
     "status": "ok",
     "timestamp": 1650011571858,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "09ibOQwF_DcU",
    "outputId": "8762c94b-cc26-458a-cb3d-d1bb6b105089"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('REINFORCE on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('REINFORCE on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第9章-策略梯度算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
